package writtenTraining.day28;

import java.util.*;

/**
 * day28:(1)数学 + 模拟： [编程题]游游的重组偶数
 */
public class Main {
    public static void main(String[] args) {
//        数学 + 模拟

        // 输入数据
        Scanner in = new Scanner(System.in);
        int q = in.nextInt();

        while(q-- > 0) {
            int num = in.nextInt();
            if(num % 2 == 0) {
                System.out.println(num);
            } else {
                // 转化为字符串操作
                char[] strNum = Integer.toString(num).toCharArray();
                int len = strNum.length;
                int dig = 3;
                StringBuilder ret = new StringBuilder();
                // 寻找一个偶数个位数即可， 并且 0 优先
                for(int i = 0 ; i < len; i++) {
                    int num1 = (int)(strNum[i] - '0');
                    if((num1 == 0 && dig != 0))  {
                        // 如果存储偶数就记录一下， 加到末尾
                        if(dig % 2 == 0) {
                            ret.append(dig + "");
                        }
                        dig = num1;
                    } else if(num1 % 2 == 0 && dig % 2 != 0) {
                        dig = num1;
                    } else {
                        // 如果不存在就加入
                        ret.append(strNum[i]);
                    }
                }  

                // 最后一步加入偶数个位
                ret.append(dig);

               System.out.println(
                (int)(ret.charAt(ret.length() - 1) - '0')  % 2
                == 0 ? ret.toString() : -1);
            }
            
            
        } 
    }
}

/**
 * day28(2): 深搜 + 剪枝：体操队形
 */


class Main2 {
    private static boolean[] path;
    private static int ret;

    public static void main(String[] args) {
//        dfs + 剪枝
        // 输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        ret = 0;
        int[] nums = new int[n + 1];
        for(int i = 1; i <= n; i++) {
            nums[i] = in.nextInt();
        }
        path = new boolean[n+1];


        dfs(nums,1);


        // 输出
        System.out.println(ret);
    }


    private static void dfs(int[]nums, int pos) {
//         递归出口
        if(pos == nums.length) {
            ret++;
            return;
        }


        for(int i = 1; i < nums.length; i++) {
            if(!path[i]) {
//                 如果遇到不符合条件的就直接剪掉整个分支
                if(path[nums[i]]) {
                    return;
                }
                path[i] = true;
                dfs(nums,pos + 1);

                //     回溯
                path[i] = false;
            }

        }
    }
}


/**
 * day28(3)：树形dp: NC6 二叉树中的最大路径和
 */


class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
      this.val = val;
    }
  }




 class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return int整型
     */
    int ret = -0x3f3f3f3f;
    public int maxPathSum (TreeNode root) {
        // 树形dp
        dfs(root);
        return ret;
    }

    private int dfs(TreeNode root) {
        if(root == null) {
            return 0;
        }

        // 注意这里只允许加上整数 和 0 才能更大
        // 所以去负数
        int leftSum =  Math.max(0,dfs(root.left));
        int rightSum =  Math.max(0,dfs(root.right));

        // 统计最终结果
        ret = Math.max(ret,leftSum + rightSum + root.val);

        // 确定左子树 和 右子树其中一个返回
        return Math.max(leftSum,rightSum) + root.val;
    }
}